HPAVC

home *** CD-ROM | disk | FTP | other *** search

/ HPAVC / HPAVC CD-ROM.iso / pc / FGL402B.ZIP / MANUALS.ARJ / USER13.DOC < prev next >

Wrap

Text File | 1995-02-06 | 31.2 KB | 757 lines

Chapter 13 Special Effects 288 Fastgraph User's Guide Overview This chapter will discuss the Fastgraph routines that help produce special visual effects. These include the ability to dissolve the screen contents in small increments, scroll areas of the screen, change the physical origin of the screen, and set up a split screen environment. The accompanying example programs illustrate how to use these routines to produce some interesting effects. Screen Dissolving Screen dissolving is the process of replacing the entire screen contents in random small increments instead of all at once. Fastgraph includes two routines, fg_fadeout and fg_fadein, for this purpose. The fg_fadeout routine incrementally replaces the visual page contents with pixels of the current color, while fg_fadein incrementally replaces the visual page contents with the hidden page contents (that is, the page defined in the most recent call to fg_sethpage). Both routines accept an integer argument that defines the delay between each incremental replacement. A value of zero means to perform the replacement as quickly as possible, while 1 is slightly slower, 2 is slower yet, and so forth. The fg_fadeout and fg_fadein routines have no effect in text video modes and always work with video pages, even if a virtual buffer is active. Example 13-1 shows how to use fg_fadeout. The program, which runs in any graphics video mode, first fills the screen with a rectangle of color 2. After waiting for a keystroke, the program incrementally replaces the screen contents with pixels of color 15 (the current color index when fg_fadeout is called). After another keystroke, the program exits gracefully. Example 13-1. #include <fastgraf.h> void main(void); void main() { int old_mode; fg_initpm(); old_mode = fg_getmode(); fg_setmode(fg_automode()); fg_setcolor(2); fg_rect(0,fg_getmaxx(),0,fg_getmaxy()); fg_waitkey(); fg_setcolor(15); fg_fadeout(0); fg_waitkey(); fg_setmode(old_mode); fg_reset(); } Chapter 13: Special Effects 289 Example 13-2 shows how to use fg_fadein in any 320x200 color graphics video mode. The program first fills the screen with a rectangle of color 2 and then fills video page 1 with a rectangle of color 1. After waiting for a keystroke, the program incrementally transfers the contents of page 1 to the visual page. After the call to fg_fadein, both page 0 (the visual page) and page 1 (the hidden page) will contain rectangles of color 1 that fill the entire video page. Finally, the program waits for another keystroke before returning to DOS. Example 13-2. #include <fastgraf.h> #include <stdio.h> #include <stdlib.h> void main(void); void main() { int new_mode, old_mode; fg_initpm(); new_mode = fg_bestmode(320,200,2); if (new_mode < 0 || new_mode == 12) { printf("This program requires a 320 "); printf("x 200 color graphics mode.\n"); exit(1); } old_mode = fg_getmode(); fg_setmode(new_mode); fg_allocate(1); fg_sethpage(1); fg_setcolor(2); fg_rect(0,319,0,199); fg_setpage(1); fg_setcolor(1); fg_rect(0,319,0,199); fg_waitkey(); fg_fadein(0); fg_waitkey(); fg_freepage(1); fg_setmode(old_mode); fg_reset(); } You also can produce some appealing visual effects by replacing the screen contents in a non-random fashion using the fg_restore or fg_transfer routines. For example, you could copy the hidden page contents to the visual page through a series of concentric rectangular areas, each slightly larger than the previous, until the entire screen is copied. Another interesting effect is to start around the screen perimeter and proceed toward the screen 290 Fastgraph User's Guide center, thus producing a "snake-like" effect. Experimenting with such techniques may reveal other effects that suit your application. Scrolling Another useful effect is scrolling, and Fastgraph provides a routine that performs vertical scrolling within a given region of the active video page. The fg_scroll routine scrolls a region defined in screen space or character space. It can scroll up or down and offers two types of scrolling: circular and end-off. In circular scrolling, rows that scroll off one edge of the defined region appear at its opposite edge. In end-off scrolling, such rows simply wind up above or below the scrolling area. The following diagrams illustrate the two types of scrolling. end-off scrolling circular scrolling before after before after C B A A A A B B In these diagrams, the area bounded by the double lines is the scrolling region, as specified in the call to fg_scroll. Also, the scrolling direction is assumed to be down (that is, toward the bottom of the screen), and the number of rows to scroll is the height of the area designated B. The number of rows to scroll is often called the scrolling increment. For the end-off scrolling example, the scrolling operation transfers region A downward so part of it is copied into area B. The area C (which is the same size as area B) at the top of the scrolling region is filled with pixels of the current color index (as defined in the most recent call to fg_setcolor), and the original contents of area B are lost. The circular scrolling example also copies region A downward into the original area B. Unlike end-off scrolling, however, circular scrolling preserves the area B by copying it to the opposite edge of the scrolling region. The fg_scroll routine takes six arguments. The first four define the scrolling region in the order minimum x coordinate, maximum x coordinate, minimum y coordinate, and maximum y coordinate. In graphics video modes, the x coordinates are extended to byte boundaries if needed. The fifth argument is the scrolling increment. It specifies the number of rows to scroll. If it is positive, the scrolling direction is toward the bottom of the screen; if it is negative, the scrolling direction is toward the top of the screen. The sixth and final argument specifies the scroll type. If this value is zero, the scroll will be circular; if it is any other value, the scroll will be end-off. If the scroll type is circular, Fastgraph will use the hidden page (as defined in the most recent call to fg_sethpage) as a workspace (more specifically, the area bounded by the scrolling region extremes on the hidden page will be used). The fg_scroll routine is disabled when a virtual buffer is active. Chapter 13: Special Effects 291 We'll now present three example programs that use the fg_scroll routine. Example 13-3 runs in any 320x200 graphics video mode. The program displays two lines of text ("line one" and "line two") in the upper left corner of the screen against a white background. It then uses fg_scroll to move the second line down four pixel rows using an end-off scroll. After waiting for a keystroke, the program again uses fg_scroll to move the text back to its original position. Note especially how fg_setcolor is used before the first call to fg_scroll to replace the "scrolled off" rows with pixels of color 15, thus preserving the white background. Example 13-3. #include <fastgraf.h> #include <stdio.h> #include <stdlib.h> void main(void); void main() { int new_mode, old_mode; fg_initpm(); new_mode = fg_bestmode(320,200,1); if (new_mode < 0 || new_mode == 12) { printf("This program requires a 320 "); printf("x 200 color graphics mode.\n"); exit(1); } old_mode = fg_getmode(); fg_setmode(new_mode); fg_setcolor(15); fg_rect(0,319,0,199); fg_setcolor(10); fg_text("line one",8); fg_locate(1,0); fg_text("line two",8); fg_waitkey(); fg_setcolor(15); fg_scroll(0,63,8,15,4,1); fg_waitkey(); fg_scroll(0,63,12,19,-4,1); fg_waitkey(); fg_setmode(old_mode); fg_reset(); } Example 13-4 is similar to example 13-3, but it runs in the 80-column color text mode (mode 3). In text modes, we cannot scroll half a character row as in example 13-3, so the program scrolls the minimum one row instead. Example 13-4. 292 Fastgraph User's Guide #include <fastgraf.h> void main(void); void main() { int old_mode; fg_initpm(); old_mode = fg_getmode(); fg_setmode(3); fg_cursor(0); fg_setcolor(7); fg_rect(0,79,0,24); fg_setattr(10,7,0); fg_text("line one",8); fg_locate(1,0); fg_text("line two",8); fg_waitkey(); fg_setcolor(7); fg_scroll(0,7,1,1,1,1); fg_waitkey(); fg_scroll(0,7,2,2,-1,1); fg_waitkey(); fg_setmode(old_mode); fg_reset(); } Example 13-5, the final scrolling example, demonstrates a circular scroll. The program runs in any 320x200 color graphics video mode; note the use of video page 1 for the workspace required when fg_scroll performs a circular scroll. The program first fills the screen with a light blue rectangle (cyan in CGA), displays a smaller white rectangle in the center of the screen, and then uses fg_move, fg_draw, and fg_paint to display a light green star (magenta in CGA) within the white rectangle. The program executes a while loop to scroll the star upward in four-pixel increments. Because the scroll is circular, rows of the star that "scroll off" the top edge of the white rectangle (whose height is the same as the scrolling region) reappear at its bottom edge. The use of fg_waitfor within the loop simply slows down the scroll. The scrolling continues until any key is pressed. Example 13-5. #include <conio.h> #include <fastgraf.h> #include <stdio.h> #include <stdlib.h> void main(void); void main() { int new_mode, old_mode; Chapter 13: Special Effects 293 fg_initpm(); new_mode = fg_bestmode(320,200,2); if (new_mode < 0 || new_mode == 12) { printf("This program requires a 320 "); printf("x 200 color graphics mode.\n"); exit(1); } old_mode = fg_getmode(); fg_setmode(new_mode); fg_allocate(1); fg_sethpage(1); fg_setcolor(9); fg_rect(0,319,0,199); fg_setcolor(15); fg_rect(132,188,50,150); fg_setcolor(10); fg_move(160,67); fg_draw(175,107); fg_draw(140,82); fg_draw(180,82); fg_draw(145,107); fg_draw(160,67); fg_paint(160,77); fg_paint(150,87); fg_paint(160,87); fg_paint(170,87); fg_paint(155,97); fg_paint(165,97); while (kbhit() == 0) { fg_waitfor(1); fg_scroll(136,184,50,150,-4,0); } fg_waitkey(); fg_freepage(1); fg_setmode(old_mode); fg_reset(); } Changing the Screen Origin Fastgraph includes two routines for changing the screen origin. By changing the screen origin, we simply mean defining the (x,y) coordinate of the upper left corner of the display area. The fg_pan routine performs this function in screen space, while the fg_panw routine does in world space. Neither routine changes the graphics cursor position. Because the function of fg_pan and fg_panw is to change the screen origin, these routines are not applicable to virtual buffers. 294 Fastgraph User's Guide Each of these routines has two arguments that specify the x and y coordinates of the screen origin. For fg_pan, the arguments are integer quantities. For fg_panw, they are floating point quantities. In the EGA, VGA, MCGA, XVGA, and SVGA graphics modes (modes 13 to 29), you can set the screen origin to any (x,y) coordinate position (that is, to any pixel). In the other graphics modes, certain restrictions exist, as imposed by specific video hardware. These constraints limit the coordinate positions that can be used as the screen origin. Fastgraph compensates for these restrictions by reducing the specified x and y coordinates to values that are acceptable to the current video mode, as shown in the following table. x will be reduced y will be reduced video mode to a multiple of: to a multiple of: 4-5 8 2 6 16 2 9 4 4 11 8 4 12 4 2 or 3 In modes 4 and 5, for instance, the x coordinate will be reduced to a multiple of 8 pixels, and the y coordinate will be reduced to a multiple of 2 pixels. In the Hercules low resolution mode (mode 12), the y coordinate reduction depends on whether or not the specified pixel row is scan doubled. Example 13-6 shows a useful effect that can be made with fg_pan or fg_panw. This program uses fg_automode to select a video mode and then draws an unfilled white rectangle. The top and bottom sides of the rectangle are intentionally drawn just smaller than the physical screen size. After waiting for a keystroke, the program uses a for loop to make the rectangle jiggle up and down. The rectangle moves because fg_pan is called inside the loop to switch the screen origin between the rectangle's upper left corner and the original origin. Note also the use of fg_waitfor to cause slight delays after each call to fg_pan. If we didn't use fg_waitfor, the changing of the origin would occur so rapidly we wouldn't notice the effect. Finally, the program restores the original video mode and screen attributes before returning to DOS. Example 13-6. #include <fastgraf.h> #include <stdio.h> #include <stdlib.h> void main(void); #define DELAY 2 #define JUMP 4 void main() { int i; int old_mode; fg_initpm(); Chapter 13: Special Effects 295 old_mode = fg_getmode(); fg_setmode(fg_automode()); fg_setcolor(15); fg_move(0,JUMP); fg_draw(fg_getmaxx(),JUMP); fg_draw(fg_getmaxx(),fg_getmaxy()-JUMP); fg_draw(0,fg_getmaxy()-JUMP); fg_draw(0,JUMP); fg_waitkey(); for (i = 0; i < 6; i++) { fg_pan(0,JUMP); fg_waitfor(DELAY); fg_pan(0,0); fg_waitfor(DELAY); } fg_setmode(old_mode); fg_reset(); } The real power of fg_pan becomes clear when it is used with fg_resize to perform smooth panning. Recall from Chapter 8 that fg_resize changes the video page dimensions in native EGA and VGA graphics modes (modes 13 to 18), the extended VGA graphics modes (20 to 23), and the SVGA graphics modes (24 to 29). We'll now present an example that shows how to use these two routines to perform panning in the low-resolution EGA graphics mode (mode 13). The method it uses also would work in any mode that supports video page resizing. Example 13-7 begins by establishing the video mode and then immediately calls fg_resize to increase the video page size to 640x400 pixels. Thus, the video page is now four times its original size. Following this, the program fills the page (the entire page, not just what is displayed) with a bright green rectangle with a white border around it. It then displays the message "Press arrow keys to pan" in the center of the 640x400 page. The main part of the program is a loop that accepts keystrokes and calls fg_pan to perform the panning one pixel at a time. When you press any of the four arrow keys, the program adjusts the x and y coordinates for the screen origin as directed. For example, pressing the up arrow key scrolls the screen upward one pixel. When we reach the edge of the video page, the program prevents further scrolling in that direction. This process continues until you press the Escape key, at which time the program restores the original video mode and screen attributes before exiting. Example 13-7. #include <fastgraf.h> void main(void); void main() { unsigned char key, aux; int old_mode; 296 Fastgraph User's Guide int x, y; fg_initpm(); old_mode = fg_getmode(); fg_setmode(13); fg_resize(640,400); fg_setcolor(2); fg_rect(0,fg_getmaxx(),0,fg_getmaxy()); fg_setcolor(15); fg_box(0,fg_getmaxx(),0,fg_getmaxy()); fg_justify(0,0); fg_move(320,200); fg_print("Press arrow keys to pan.",24); x = 0; y = 0; do { fg_getkey(&key,&aux); if (aux == 72 && y < 200) y++; else if (aux == 75 && x < 320) x++; else if (aux == 77 && x > 0) x--; else if (aux == 80 && y > 0) y--; fg_pan(x,y); } while (key != 27); fg_setmode(old_mode); fg_reset(); } Panning With Virtual Buffers The fg_pan routine is not suitable for panning a large image through a small window because it affects the entire screen. However, you can achieve this type of panning by storing the large image on an off-screen video page or in a virtual buffer and then copy the appropriate portions of it to the fixed window on the visual page. Example 13-8 illustrates this technique using a virtual buffer. Example 13-8. #include <fastgraf.h> void main(void); #ifdef FG32 char buffer[64000]; #else char huge buffer[64000]; #endif Chapter 13: Special Effects 297 void main() { unsigned char key, aux; int handle; int old_mode; int x, y; fg_initpm(); old_mode = fg_getmode(); fg_setmode(19); fg_vbinit(); handle = fg_vbdefine(buffer,320,200); fg_vbopen(handle); fg_loadpcx("CORAL.PCX",0); fg_vbclose(); fg_setcolor(2); fg_fillpage(); fg_setcolor(15); fg_box(111,208,69,130); fg_locate(3,8); fg_text("Press arrow keys to pan.",24); x = 112; y = 129; fg_vbpaste(x,x+95,y-59,y,112,129); do { fg_getkey(&key,&aux); if (aux == 72 && y < 199) y++; else if (aux == 75 && x < 223) x++; else if (aux == 77 && x > 0) x--; else if (aux == 80 && y > 59) y--; fg_vbpaste(x,x+95,y-59,y,112,129); } while (key != 27); fg_setmode(old_mode); fg_reset(); } Example 13-8 loads our familiar CORAL.PCX image into a 320x200 virtual buffer. It then sets up a 96x60 region in the middle of the visual page that will serve as a window into the larger CORAL.PCX image (this region is bounded horizontally by x=112 and x=207 and vertically by y=70 and y=129). The first call to fg_vbpaste copies the 96x60 center portion of the virtual buffer to the visual page window. The panning loop is similar to that of example 13-7, except it uses fg_vbpaste to update the window contents. Pressing the arrow keys increments or decrements the coordinates defining the source region in 298 Fastgraph User's Guide the virtual buffer. Also, note how we've adjusted the if statements to prevent fg_vbpaste from accessing pixels outside the virtual buffer. Split Screen Fastgraph provides split screen support for EGA, VGA, MCGA, and XVGA graphics modes (modes 13 through 23) for applications running on VGA or SVGA systems. When a split screen is enabled, the top portion of the screen (rows 0 through n-1, where n is the pixel row at which the split screen takes effect) will contain a subset of the visual video page. The bottom portion (starting at row n) will contain the first fg_getmaxy()-n+1 rows of video page 0. For example, suppose we're using a 200-line graphics mode and we enable a split screen at row 180. If page 1 is the visual video page, the first 180 lines of the screen would be displayed from rows 0 to 179 from page 1, and the last 20 lines would be displayed from rows 0 to 19 of page 0. A split screen environment is useful for maintaining a static image, such as a scoreboard or status box, at the bottom of the screen while scrolling the top portion. Example 13-9 demonstrates a typical split screen operation in the 320x200 XVGA graphics mode (mode 20). In this example, we'll assume we want to have a status box occupying the last 20 rows (rows 180 to 199) of the screen, while the upper 180 rows (0 to 179) will be scrolled vertically. The program begins by setting the video mode and then calling fg_measure to compute a processor- dependent delay value for slowing down the scrolling (this technique is further explained in Chapter 16). In mode 20, video memory is structured as four 320x200 physical pages. Page 1 is not visible when we draw the blue box with the white border, so we don't see it until call fg_setvpage to make page 1 the visual page. This of course also makes page 0 invisible, so we don't see the 20-pixel high red hollow box when we draw it on page 0. Once we've drawn what we've needed on pages 0 and 1, we activate the split screen by calling fg_split. The single parameter passed to fg_split is the screen row at which the split screen takes effect, or put another way, the number of rows in the top portion of the screen. In example 13-9 we call fg_split(180), so the first 180 rows of page 1 will appear at the top of the screen, and the first 20 rows of page 0 will appear at the bottom. Now we're ready to scroll the upper part of the screen (which is now page 1). Fastgraph's fg_pan routine is suitable for this purpose. We achieve the upward scrolling by incrementing the fg_pan y coordinate in a loop. We achieve the downward scrolling by decrementing the y coordinate. We must call fg_stall (or use another similar method) to force a brief delay between iterations. If we didn't do this, the full 20-row scrolling would appear almost instantly, thus losing the scrolling effect. Note that we couldn't use fg_pan to scroll the upper part of the screen in this manner without setting up a split screen environment. That's because by default fg_pan applies to the entire screen. Using the split screen provides us with two independent video pages, and when page 1 is the active video page, fg_pan doesn't touch page 0. Example 13-9. #include <fastgraf.h> void main(void); Chapter 13: Special Effects 299 void main() { int delay, y; /* initialize the video environment */ fg_initpm(); fg_setmode(20); /* define a processor-dependent panning delay */ delay = fg_measure() / 16; /* draw a blue box with a white border on page 1 */ fg_setpage(1); fg_setcolor(9); fg_fillpage(); fg_setcolor(15); fg_box(0,319,0,199); fg_move(160,100); fg_justify(0,0); fg_print("This is page 1",14); /* display what we just drew on page 1 */ fg_setvpage(1); fg_waitkey(); /* draw a red hollow box at the top of page 0 (now invisible) */ fg_setpage(0); fg_setcolor(12); fg_box(0,319,0,19); fg_setcolor(15); fg_move(160,10); fg_print("SPLIT SCREEN",12); /* activate the split screen environment, making the first */ /* 20 lines of page 0 appear at the bottom of the screen, */ /* and making the first 180 lines of page 1 appear at the top */ fg_split(180); fg_waitkey(); /* pan upward in one-line increments, displaying the rest of */ /* page 1 */ fg_setpage(1); for (y = 0; y <= 20; y++) { fg_pan(0,y); fg_stall(delay); } fg_waitkey(); 300 Fastgraph User's Guide /* pan back down in one-line increments to the original position */ for (y = 20; y >= 0; y--) { fg_pan(0,y); fg_stall(delay); } fg_waitkey(); /* restore 80x25 text mode and exit */ fg_setmode(3); fg_reset(); } To switch from a split screen environment back to a "single page" environment, call fg_split with a row parameter equal to the vertical screen resolution for the current video mode. Summary of Special Effects Routines This section summarizes the functional descriptions of the Fastgraph routines presented in this chapter. More detailed information about these routines, including their arguments and return values, may be found in the Fastgraph Reference Manual. FG_FADEIN incrementally replaces the visual page contents with the hidden page contents. This routine has no effect in text video modes and is not applicable to virtual buffers. FG_FADEOUT incrementally replaces the visual page contents with pixels of the current color. This routine has no effect in text video modes and is not applicable to virtual buffers. FG_PAN changes the screen origin (the upper left corner of the screen) to the specified screen space coordinates. This routine has no effect in text video modes and is not applicable to virtual buffers. FG_PANW is the world space version of the fg_pan routine. FG_RESIZE changes the dimensions of a video page in EGA and VGA graphics modes. This routine is disabled when a virtual buffer is active. FG_SCROLL vertically scrolls a region of the active video page. The scrolling may be done either up or down, using either an end-off or circular method. Circular scrolling uses part of the hidden page as a temporary workspace. This routine is not functional when a virtual buffer is active. FG_SPLIT enables or disables a split screen environment in EGA, VGA, MCGA, and XVGA graphics modes.